package Demo1;

/**
 * Description:
 * Date: 2025-10-11
 * Time: 15:04
 */
public class Test {



    public static void main1(String[] args) {
        //多态第一步：在继承体系中
        //此时发生了向上转型1，将子类的引用对象 赋值给了 父类的引用 即 父类引用 引用了 子类对象
        Animal animal = new Dog();
        animal.name = "大黄";
        animal.age = 15;
        System.out.println(animal.name);
        System.out.println(animal.age);
    }

    //这里通过父类引用来接收子类对象，也发生了向上转型2
    public static void func(Animal animal) {
        animal.eat();
    }

    public static Animal func2() {
        Dog dog = new Dog("大黄", 15);

        //这里通过父类引用作为返回值来接收子类对象类发生 向上转型3
        return dog;
    }

    public static void main2(String[] args) {
        Dog dog = new Dog("大黄", 15);
        func(dog);
    }

    public static void main3(String[] args) {
        Animal animal = new Dog("大黄", 15);
        //向上转型的缺点： 通过父类的引用时无法调用子类特有的方法，只能调用父类自己拥有的方法
//        animal.bark();
        animal.eat();
    }

    //多态第二步：在子类中重写父类的方法
    public static void main4(String[] args) {
        Animal animal = new Dog("大黄", 15);

        //此时我用父类引用调用了父类自己的eat()方法，但是却执行了子类中eat()的方法，此时发生了动态绑定
        //动态绑定发生的条件：1.发生向上转型 -- > 父类引用  引用了 子类对象
        //                2.调用了子啊 父类 和 子类 重写的那个方法
        // 这样就会在父类引用调用重写的那个方法时，java所执行的那个方法就会动态的选择执行子类中的方法
        animal.eat();

        animal = new Cat("小白",3);
        animal.eat();
        //此时animal引用的对象不一样，但是 调用的是同一个方法， 却表现出不同的现象。此时这种思想，我们就叫做多态
    }

    public static void main(String[] args) {
        //向下转型：具有一定的风险

        Animal animal = new Dog("大黄", 15);
        //这里向下转型成功是因为 animal 本身就是 Dog类的
        Dog dog = (Dog)animal;//向下转型
        dog.bark();

        //不是所有的向下转型 都是可以成功的
        Animal animal1 = new Cat("小白", 5);
        //这里向下转型失败，不可能将一只猫 转型 成一只狗的
        //虽然在编译时骗过的编译器，但它运行时是编译失败的
        Dog dog1 = (Dog) animal1;
        dog1.bark();//这里是编译失败的
    }


}